package com.mew.slots.core.common.roller.ili.a;

import java.io.File;
import java.io.FileInputStream;
import java.io.IOException;
import java.io.UnsupportedEncodingException;
import java.util.ArrayList;

public class Iliread {

    public static String rootpath = System.getProperty("user.dir");

    /**
     * name  16
     * 长度 4
     * 偏移 4
     * 一个组24
     *
     * @throws IOException
     */
    public Ili read(File iliFile,int size) throws IOException {
        FileInputStream file  = new FileInputStream(iliFile);

        //头
        byte[] bytes = new byte[1024];
        ArrayList<Byte> barr = new ArrayList<>();
        long l = 0;
        while (file.read(bytes)!=-1){
            for (byte b : bytes) {
                l++;
                barr.add(b);
            }
        }

        Ili ili = new Ili();
        if (ili.notIli(barr) || ili.main!=barr.get(2) || ili.sub!=barr.get(3)){
            return null;
        }

        ili.ia_num = byteArrToInt(arrToBytes(barr, 4,4 ));

        //每组
        for (int i = 0; i < ili.ia_num; i++) {
            Ili.Iarray iarray = toIli(arrToBytes(barr, 8 + i * 24, 24));
            ili.iarrays.put(iarray.getName(),iarray);
        }

        //组内数据  图案
        for (Ili.Iarray iarray : ili.iarrays.values()) {

            //偏移值
            int offset = iarray.offset;

            //线
            for (int j = 0; j < iarray.inum; j++) {

                ArrayList<Integer> list = new ArrayList<>();
                for (int k = 0; k < size; k++) {
                    list.add(byteArrToInt(arrToBytes(barr, offset + k*4, 4)));
                }
                iarray.ic.add(list);
                offset += size*4;
            }

        }
        file.close();
        //香蕉 0  //西瓜1	//芒果2	//葡萄3	//菠萝4	//铃铛5	//樱桃6	//Bar7	//橙子8 //贝壳9    //scatter10
        return ili;

    }

    /**
     * name  16
     * 长度 4
     * 偏移 4
     * 一个组24
     *
     * @throws IOException
     */
    public Ili read2(String path,int size) throws IOException {
        FileInputStream file  = new FileInputStream(rootpath + path);

        //头
        byte[] bytes = new byte[1024];
        ArrayList<Byte> barr = new ArrayList<>();
        long l = 0;
        while (file.read(bytes)!=-1){
            for (byte b : bytes) {
                l++;
                barr.add(b);
            }
        }

        Ili ili = new Ili();
        if (ili.notIli(barr) || ili.main!=barr.get(8) || ili.sub!=barr.get(9)){
            return null;
        }

        ili.ia_num = byteArrToInt(arrToBytes(barr, 10,4 ));

        //每组
        for (int i = 0; i < ili.ia_num; i++) {
            Ili.Iarray iarray = toIli(arrToBytes(barr, 14 + i * 24, 24));
            ili.iarrays.put(iarray.getName(),iarray);
        }

        //组内数据  图案
        for (Ili.Iarray iarray : ili.iarrays.values()) {

            //偏移值
            int offset = iarray.offset;

            //线
            for (int j = 0; j < iarray.inum; j++) {

                ArrayList<Integer> list = new ArrayList<>();
                for (int k = 0; k < size; k++) {
                    list.add(byteArrToInt(arrToBytes(barr, offset + k*4, 4)));
                }
                iarray.ic.add(list);
                offset += size*4;
            }

        }
        file.close();
        //香蕉 0  //西瓜1	//芒果2	//葡萄3	//菠萝4	//铃铛5	//樱桃6	//Bar7	//橙子8 //贝壳9    //scatter10
        return ili;

    }


    public static ArrayList<Integer> byte2short(int start,byte[] b){
        ArrayList<Integer> res = new ArrayList<>();

        for (int j = start; j < (b.length-start) / 2; j+=2) {
            Integer l = 0;
            for (int i = j; i < j+2; i++) {
                l<<=8; //<<=和我们的 +=是一样的，意思就是 l = l << 8
                l |= (b[i] & 0xff); //和上面也是一样的  l = l | (b[i]&0xff)
            }
            res.add(l);
        }
        return res;
    }

    /**
     * byte数组转换为整数
     * 第0个byte与上0xff,生成整数,在右移24位，取得一个整数
     * 第1个byte与上0xff,生成整数,在右移16位，取得一个整数
     * 第2个byte与上0xff,生成整数,在右移8位，取得一个整数
     * 第3个byte与上0xff,生成整数
     * 把四个整数做或操作,转换为已整数
     */
    public static int byteArrToInt(byte[] arr) {
        int x = ((arr[3] & 0xff) << 24) | ((arr[2] & 0xff) << 16) | ((arr[1] & 0xff) << 8) | (arr[0] & 0xff);
        return x;
    }


    /*
     * 把整数转换为字节数组：整数是32位，8位一个字节，依次读取8位，转化为字节数组
     * 整数与0xff,取得最后8位,生成整数,再强转为第3个byte
     * 整数右移8位,与0xff,取得倒数第二组8位,生成整数,再强转为第2个byte
     * 整数右移16位,与0xff,取得倒数第3组8位,生成整数,再强转为第1个byte
     * 整数右移24位,与0xff,取得倒数第4组8位,生成整数,再强转为第0个byte
     */
    public static byte[] intToByteArr(int x){

        byte[] arr = new byte[4];
        arr[0]= (byte)(x & 0xff);
        arr[1]= (byte)(x>>8 & 0xff);
        arr[2]= (byte)(x>>16 & 0xff);
        arr[3]= (byte)(x>>24 & 0xff);

        return arr;
    }

    public Ili.Iarray toIli(byte[] b) throws UnsupportedEncodingException {

        byte[] bname = new byte[16];
        byte[] binum = new byte[4];
        byte[] boffset = new byte[4];

        Ili.Iarray iarray = new Ili.Iarray();
        for (int i = 0; i < b.length; i++) {
            if (i<16){
                bname[i] = b[i];
            }else if (i < 20){
                binum[i-16] = b[i];
            }else {
                boffset[i-20] = b[i];
            }
        }

        iarray.name = new String(bname,"utf-8").replaceAll("\\u0000", "");
        iarray.inum = byteArrToInt(binum);
        iarray.offset = byteArrToInt(boffset);

        return iarray;
    }

    byte[] arrToBytes(ArrayList<Byte> arr,int s,int l){
        byte[] bytes = new byte[l];
        for (int i = 0; i < bytes.length; i++) {
            bytes[i] = arr.get(s+i);
        }

        return bytes;

    }
    public static void main(String[] args) throws IOException {

    }
}
